package com.example.orderfood2.Repository;

import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.os.Build;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

public class StudentAvatarRepository extends BaseRepository {
    public StudentAvatarRepository(Context context) {
        super(context);
    }

    //    根据学生id上传头像
    public void uploadAvatar(Integer studentId, byte[] avatar) {
        open();
        // 先检查是否已存在头像记录
        if (isAvatarExists(studentId)) {
            // 更新现有头像
            String updateSql = "UPDATE student_avatar SET avatar = ? WHERE Student_id = ?";
            Object[] updateArgs = {avatar, studentId};
            database.execSQL(updateSql, updateArgs);
        } else {
            // 插入新头像记录
            String insertSql = "INSERT INTO student_avatar (Student_id, avatar) VALUES (?, ?)";
            Object[] insertArgs = {studentId, avatar};
            database.execSQL(insertSql, insertArgs);
        }
        close();
    }

    // 检查头像是否存在
    private boolean isAvatarExists(Integer studentId) {
        Cursor cursor = null;
        boolean exists = false;

        try {
            String sql = "SELECT 1 FROM student_avatar WHERE Student_id = ?";
            cursor = database.rawQuery(sql, new String[]{String.valueOf(studentId)});
            exists = cursor != null && cursor.moveToFirst();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }

        return exists;


    }

    // 根据学生id获取头像
    public byte[] getAvatarByStudentId(Integer studentId) {
        open();
        byte[] avatarBytes = null;
        Cursor cursor = null;

        try {
            String sql = "SELECT avatar FROM student_avatar WHERE Student_id = ?";
            cursor = database.rawQuery(sql, new String[]{String.valueOf(studentId)});

            if (cursor != null && cursor.moveToFirst()) {
//                用于从数据库查询结果中获取指定列的二进制大对象(BLOB)数据
                avatarBytes = cursor.getBlob(0);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null) {
                cursor.close();
            }
            close();
        }

        return avatarBytes;
    }

    // 将Bitmap转换为byte数组
//    Bitmap 是 Android 中的一个重要图形数据类型
    public static byte[] bitmapToByteArray(Bitmap bitmap) {
        // 2. 尺寸压缩（50%）
        int compressedWidth = bitmap.getWidth() / 2;
        int compressedHeight = bitmap.getHeight() / 2;
        Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, compressedWidth, compressedHeight, true);

        // 3. 质量压缩（50%）
        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        try {
            scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 50, stream);
            return stream.toByteArray();
        } finally {
            try {
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            scaledBitmap.recycle();
            if (scaledBitmap != bitmap) {
                bitmap.recycle();
            }
        }
    }

    // 将byte数组转换为Bitmap
    public static Bitmap byteArrayToBitmap(byte[] byteArray) {
        if (byteArray == null) return null;

        // 1. 先解码为Bitmap
        Bitmap bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.length);
        if (bitmap == null) return null;

        // 2. 读取EXIF信息获取旋转角度
        int rotationAngle = getRotationAngle(byteArray);

        // 3. 如果需要旋转，校正方向
        if (rotationAngle != 0) {
            Matrix matrix = new Matrix();
            matrix.postRotate(rotationAngle);
            // 创建旋转后的新Bitmap
            Bitmap rotatedBitmap = Bitmap.createBitmap(
                    bitmap,
                    0, 0,
                    bitmap.getWidth(), bitmap.getHeight(),
                    matrix,
                    true
            );
            // 回收原始Bitmap，避免内存泄漏
            bitmap.recycle();
            return rotatedBitmap;
        }

        return bitmap;
    }
    // 从字节数组中读取图片的旋转角度（EXIF信息）
//    该函数用于从图片字节数组中读取EXIF信息，获取图片的旋转角度。主要功能包括：
//    将字节数组转换为输入流；
//    根据Android版本兼容性创建ExifInterface对象；
//    读取图片方向属性并转换为对应旋转角度（90、180、270度或0度）；
//    处理异常并关闭资源。
    private static int getRotationAngle(byte[] byteArray) {
        InputStream inputStream = new ByteArrayInputStream(byteArray);
        ExifInterface exif = null;

        try {
            // 兼容不同Android版本的ExifInterface构造方法
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                exif = new ExifInterface(inputStream);
            } else {
                // 低版本需要使用临时文件（简化处理，实际可优化）
                exif = new ExifInterface(inputStream);
            }

            // 获取EXIF中的方向标签
            int orientation = exif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_UNDEFINED
            );

            // 根据方向标签返回旋转角度
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    return 90;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    return 180;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    return 270;
                default:
                    return 0;
            }
        } catch (IOException e) {
            e.printStackTrace();
            return 0;
        } finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 从图片文件中读取旋转角度（根据EXIF信息）
     * @param imagePath 图片文件的绝对路径
     * @return 旋转角度（0/90/180/270），默认返回0
     */
    public static int getBitmapRotationAngle(String imagePath) {
        if (imagePath == null || imagePath.isEmpty()) {
            return 0;
        }

        ExifInterface exif = null;
        try {
            // 打开图片文件并读取EXIF信息
            exif = new ExifInterface(imagePath);
        } catch (IOException e) {
            e.printStackTrace();
            return 0; // 读取失败时默认不旋转
        }

        // 获取EXIF中的"方向"标签值（默认值为ORIENTATION_UNDEFINED）
        int orientation = exif.getAttributeInt(
                ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_UNDEFINED
        );

        // 根据方向值返回对应的旋转角度
        switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                return 90;
            case ExifInterface.ORIENTATION_ROTATE_180:
                return 180;
            case ExifInterface.ORIENTATION_ROTATE_270:
                return 270;
            // 其他情况（如正常方向、翻转等）默认不旋转
            default:
                return 0;
        }
    }

}
